# -*- coding: UTF-8 -*-

from tkinter import *
import sys
import socket

import winsound


class Vue():
    def __init__(self, parent):
        self.master = Tk()
        #self.master.maxsize(800, 600)
        self.parent = parent
        
        #Methodes pour acceder a la taille determinee au demarrage de la partie pour l'espace occupe par le jeu
        self.widthEspaceJeu = self.parent.getWidthEspaceJeu()
        self.heightEspaceJeu = self.parent.getHeightEspaceJeu()
        
        self.listeCouleursJoueurs = None
        
        self.frameCourant = None #FrameCourant est toujours le frame presentement affiche
        self.afficherLogin()
        
        self.master.protocol("WM_DELETE_WINDOW", self.parent.retirerDeLaListe) #Retire le joueur de la liste quand il ferme la fenêtre du programme
     
    def afficherLogin(self): #Methode pour afficher le Frame de login avant que la partie commence
        self.frameLogin = Frame(self.master, width=400, height=400) #Frame de login
        self.frameLogin.pack()
        self.frameCourant = self.frameLogin 
        self.frameLogin.bind_all("<Return>", lambda e: self.parent.validerLogin(self.entIP.get(), self.entNom.get(), self.entMdp.get())) #Peu importe ou se trouve le focus, quand on appuie sur enter, ca essaie de se connecter au serveur avec les informations entrees
        
        self.etiqNom = Label(self.frameLogin, text="Nom d'utilisateur")
        self.etiqNom.pack()
    
        self.entNom = Entry(self.frameLogin)
        self.entNom.insert(0, "Adam")
        self.entNom.pack()
        self.entNom.focus() #Donne le focus au champ pour entrer le nom
        
        self.etiqMdp = Label(self.frameLogin, text="Mot de passe")
        self.etiqMdp.pack()
        
        self.entMdp = Entry(self.frameLogin)
        self.entMdp.insert(0, "Smith")
        self.entMdp.pack()
        
        self.etiqIP = Label(self.frameLogin, text="Adresse IP")
        self.etiqIP.pack()
        
        self.entIP = Entry(self.frameLogin)
        self.entIP.insert(0, self.parent.getMyIp()) #Ip par defaut est le notre
        self.entIP.pack()
        
        self.bouton = Button(self.frameLogin, text="Ok", command=lambda:self.parent.validerLogin(self.entIP.get(), self.entNom.get(), self.entMdp.get())) #Essaie de valider le login si on appuie sur le bouton
        self.bouton.pack()
    
    def afficherSalle(self):        
        self.frameSalle = Frame(self.master, width=self.widthEspaceJeu, height=self.heightEspaceJeu)
        self.changerFrame(self.frameSalle)
        self.frameSalle.pack_propagate(0)
        
        self.frameSalle.bind_all("<Return>", lambda insertionTexte: self.insererTexteChat(self.entreChat.get()))
        
        self.etiqSalle = Label(self.frameSalle, text="Lobby")
        self.etiqSalle.grid(row=0, column=0)
        
        self.listbox = Listbox(self.frameSalle)
        self.listbox.grid(row=1, column=0)
        
        self.etiqNb = Label(self.frameSalle)
        self.etiqNb.grid(row=2, column=0)
        
        self.etiqChat = Label(self.frameSalle, text="Chat")
        self.etiqChat.grid(row=0, column=3)
        
        self.textChat = Text(self.frameSalle, width=100)
        self.textChat.grid(row=1, column=4, columnspan=4)
        
        self.boutonChat = Button(self.frameSalle, text="Envoyer", command=lambda: self.insererTexteChat(self.entreChat.get()))
        self.boutonChat.grid(row=3, column=5, sticky=W)
        
        self.entreChat = Entry(self.frameSalle, width=50)
        self.entreChat.grid(row=3, column=4, sticky=W)
        self.entreChat.focus()
        
        if self.parent.isJoueurCourantCreateurPartie(): #Seul le createur de la partie a le bouton pour demarrer la partie
            self.boutonDebutPartie = Button(self.frameSalle, text="Debuter la partie", command=self.parent.envoiDebutPartie)
            self.boutonDebutPartie.grid(row=3, column=6, sticky=W)
        
        self.etiqAIp = Label(self.frameSalle, text="IP du serveur : " + self.parent.getIpServeur())
        self.etiqAIp.grid(row=3, column=0)
        
        self.musique()        
    
    def insererTexteChat(self, message, isSourceHud=False): #Si isSourceHud est a true, cela signifie qu'il y a une partie en cours, ce n'est donc pas le meme champs a mettre a jour que dans le lobby
        self.parent.insererTexteChat(message)
        
        if isSourceHud:
            self.hud.entreChat.delete(0, END)
            self.canvas.canvas.focus_set()
        else:
            self.entreChat.delete(0, END)
            
    #Methode qui va construire la listbox de la salle d'attente
    def miseAJours(self):
        self.listbox.delete(0, END)
        self.listeJoueurs = self.parent.creeListeJoueurs() #Recree la liste des joueurs a chaque fois au cas ou elle a change
        joueurDansLaListe = False
        
        if not self.listeCouleursJoueurs: #Si la liste de couleur est encore a None, on va la chercher sur le serveur
            self.listeCouleursJoueurs = self.parent.retournerListeCouleursJoueurs()
            
        self.item = 0
        
        #On affiche le nombre de joueurs dans la liste
        if len(self.listeJoueurs) == 1: #Cas pour que le singulier soit employe pour "joueur"
            self.etiqNb.config(text=str(len(self.listeJoueurs)) + " joueur dans le lobby")
        else:
            self.etiqNb.config(text=str(len(self.listeJoueurs)) + " joueurs dans le lobby")
        
        self.etiqNb.grid(row=2, column=0)
            
        #On regarde si le joueur courant est encore dans la liste
        for nom in self.listeJoueurs:
            if nom == self.parent.getJoueurCourant():
                joueurDansLaListe = True
                
        if joueurDansLaListe:
            for joueur in self.listeJoueurs:
                self.listbox.insert(END, joueur)
                self.listbox.itemconfig(self.item, {'bg':self.listeCouleursJoueurs[self.listeJoueurs.index(joueur)], 'fg':'white'})
                self.item += 1
    
    def raffraichirChat(self):
        self.leTexte = ""
        self.listeChat = self.parent.creeListeChat()
        self.textChat.delete(1.0, END)
        
        for texte in self.listeChat:
            self.leTexte += texte + "\n"
            
        self.textChat.insert(END, self.leTexte)
        self.textChat.see(END)

    def musique(self): #TO-DO: Mettre la lecture de la musique dans le modele
        pass
        #try:
        #    winsound.PlaySound('saxguy.wav',winsound.SND_FILENAME | winsound.SND_ASYNC | winsound.SND_LOOP )
        #except:
            #print("no sound!")
        
    def changerFrame(self, leFrame):
        self.frameCourant.pack_forget()
        self.frameCourant = leFrame
        leFrame.pack()
        
    def afficherPartie(self):
        width = self.parent.modele.widthEspaceJeu
        height = self.parent.modele.heightEspaceJeu
        worldSize = self.parent.modele.worldSize
        self.vueCourante = self.parent.modele.galaxie

        ### ARRET DE LA MUSIQUE DE SALLE D'ATTENTE
        #try:
            #winsound.PlaySound('saxguy.wav',winsound.SND_FILENAME | winsound.SND_PURGE )
        #except:
            #print("no sound!")
        ### Je savais pas trop ou mettre cela sinon!
        
        self.minimap = Minimap()
        self.frameJeu = Frame(self.master, width=width, height=height, background="black")
        self.changerFrame(self.frameJeu)
        self.frameDiplomatie = FrameDiplomatie(self, self.frameJeu, int(width / 3), int(height / 3))
        self.frameHaut = FrameHaut(self, self.frameJeu, width, int(height / 20))
        self.menuNavigation = MenuNavigation(self, self.frameJeu, int(height / 10), int(width / 5))
        self.canvas = Interface(self, self.frameJeu, width, height, worldSize)
        self.hud = Hud(self, self.frameJeu, width, height, worldSize)
        
    def retourVue(self):
        if self.vueCourante.typeVue() == "Systeme":
            self.vueCourante = self.vueCourante.galaxieParent
        if self.vueCourante.typeVue() == "Planete":
            self.vueCourante = self.vueCourante.systemeParent
            
        self.canvas.uniteCourante = []
        
        if self.hud.frameMilieuLequel == "Construction":
            self.hud.arretPlacerConstruction()
            self.hud.afficherFrameConstruction()
        
    def dessinerAttaque(self, coord1, coord2): #TO-DO: Verifier les problemes d'affichage des lasers
        self.canvas.dessinAttaque.append([coord1, coord2, 5])
        try:
            winsound.PlaySound('laser.wav', winsound.SND_FILENAME | winsound.SND_ASYNC)
        except:
            print("No sound!")
       
class MenuNavigation(): #TO-DO: Resizer la listBox
    def __init__(self, parent, frame, height, width):
        self.parent = parent
        self.height = height
        self.width = width
        self.vueCourante = self.parent.vueCourante
        self.frame = frame
        self.menuNavigation = Frame(self.frame, height=height, width=width, background="black", relief=RIDGE, borderwidth=10)
        self.menuNavigation.pack(side=LEFT)        

        self.scrollbar = Scrollbar(self.menuNavigation)
        self.scrollbar.pack(side=RIGHT, fill=Y)

        self.mylist = Listbox(self.menuNavigation, yscrollcommand=self.scrollbar.set)   
        
        self.mylist.pack(side=LEFT, fill=BOTH)
        self.scrollbar.config(command=self.mylist.yview)    
    
    def insertionElements(self):
        self.mylist.delete(0, END)
        
        self.mylist.insert(END, "----- GALAXIE -----")
        for systeme in self.parent.parent.modele.galaxie.listeSystemes:
            systemeInsere = False
            entiteSystemeCount = 0
            
            for entiteSysteme in systeme.listeEntites:
                if entiteSysteme.joueur == self.parent.parent.getJoueurCourant() and entiteSysteme.typeEntite() == "Unite":
                    entiteSystemeCount += 1
            
            for planete in systeme.listePlanetes:
                entitePlaneteCount = 0
            
                for entitePlanete in planete.listeEntites:
                    if entitePlanete.joueur == self.parent.parent.getJoueurCourant() and entitePlanete.typeEntite() == "Unite":
                        entitePlaneteCount += 1
                
                if entitePlaneteCount > 0:
                    if not systemeInsere:
                        self.mylist.insert(END, systeme.nom + " (" + str(entiteSystemeCount) + " unites)")
                        systemeInsere = True
                        
                    self.mylist.insert(END, "--- " + planete.nom + " (" + str(entitePlaneteCount) + " unites)")
                    
class FrameHaut():
    def __init__(self, parent, frame, width, height):
        self.parent = parent
        self.vueCourante = self.parent.vueCourante
        self.frame = frame
        self.frameHaut = Frame(self.frame, height=height, background="black", relief=RIDGE, borderwidth=10)
        self.frameHaut.pack(side=TOP, fill=X)
        self.ress = ""
        self.bouttonDiplomatie = Button(self.frameHaut, text="Diplomatie", bg="blue", fg="white", font=("Helvetica", 12), command=self.parent.frameDiplomatie.afficher)
        self.bouttonDiplomatie.pack(side=RIGHT)
        self.bouttonTech = Button(self.frameHaut, text="Tech-Tree", bg="blue", fg="white", font=("Helvetica", 12)) #command=blabla
        self.bouttonTech.pack(side=RIGHT)
        self.ressourcesJoueur = []
        self.partieEstCommencer = 0
        
        #self.backgroundFrameHaut = PhotoImage(file="images/frameHaut.GIF")
        #self.ressourcesJoueur.configure(image=self.backgroundFrameHaut)

    def redraw(self):
        self.vueCourante = self.parent.vueCourante

        #rafraichissement des ressources du joueur sur une planete        
        if self.vueCourante.typeVue() == "Planete" or self.vueCourante.typeVue() == "Systeme":
            #Si c'est la premiere fois, creation des labels...
            if self.partieEstCommencer == 0:
                self.partieEstCommencer = 1
                couleurRessource = ""
                self.ress = ""
                
                for indexRessource in range(len(self.vueCourante.typeRessources)):
                    self.ress = self.vueCourante.typeRessources[indexRessource] + ": " + str(self.vueCourante.ressourcesJoueur[indexRessource])
                    ###couleur du texte = couleur de la ressource
                    if indexRessource == 0:
                        couleurRessource = "grey"
                    elif indexRessource == 1:
                        couleurRessource = "black"
                    elif indexRessource == 2:
                        couleurRessource = "green"
                    elif indexRessource == 3:
                        couleurRessource = "LightPink"
                    elif indexRessource == 4:
                        couleurRessource = "white"
                    elif indexRessource == 5:
                        couleurRessource = "red"
                    elif indexRessource == 6:
                        couleurRessource = "gold"
                    elif indexRessource == 7:
                        couleurRessource = "burlywood4"
                    self.ressourcesJoueur.append(Label(self.frameHaut, text=self.ress, fg=couleurRessource, bg="blue", relief=RIDGE, borderwidth=3, font=("Helvetica", 13)))
                    self.ressourcesJoueur[indexRessource].pack(side=LEFT, fill=X)
                    self.ressourcesJoueur[indexRessource].config(text=self.ress)

        if self.vueCourante.typeVue() == "Galaxie": #Pas de ressources dans la Galaxie
            for indexRessource in range(len(self.ressourcesJoueur)):
                self.ressourcesJoueur[indexRessource].forget()

class FrameDiplomatie():  #TO-DO: Verifier le MVC de cette classe          ####### Frame de test ( par Marc )
    def __init__(self, parent, frame, width, height):
        self.parent = parent
        self.frame = frame
        self.frameDiplomatie = Frame(self.frame, width=width , height=height, background="white")
        #self.frameDiplomatie.place(x=400,y=40,anchor=NE)
        self.boutonTestDiplomatie = Button(self.frameDiplomatie, text="test!", bg="blue", fg="white") 
        self.boutonTestDiplomatie.pack()
        
        self.estAfficher = False;
    def afficher(self):
        if self.estAfficher:
            self.estAfficher = False
        else:
            self.estAfficher = True
    def redraw(self): 
        if self.estAfficher:
            self.frameDiplomatie.place(x=0, y=40, anchor=NE)

class Minimap(): #Sert a representer le carre brun de l'espace visible dans la minimap
    def __init__(self, posX=0, posY=0, tag="minimap"):
        self.posX = posX
        self.posY = posY

class Interface(): #L'ecran du jeu en tant que tel
    def __init__(self, parent, frame, width, height, worldSize):
        self.parent = parent
        self.vueCourante = self.parent.vueCourante
        self.frame = frame
        self.clicEnCours = 0
        self.clicEnCoursX = 0
        self.clicEnCoursY = 0
        
        #Variables utilisees pour le carre quand on drag
        self.selectionDebut = None
        self.selectinFin = None
        self.selectionEnCours = None
        
        self.canvas = Canvas(self.frame, scrollregion=(0, 0, worldSize, worldSize), width=width, height=height)
        self.canvas.pack()
        self.canvas.bind("<Button-1>", self.carreSelectionDebut) #Clic gauche fait l'action selection
        #self.canvas.bind("<Button-2>",self.recentrer)
        self.canvas.bind("<ButtonRelease-1>", self.carreSelectionFin)
        self.canvas.bind("<B1-Motion>", self.carreDrag)
        self.canvas.bind("<Button-3>", self.action) #Clic droit fait l'action action
        self.canvas.bind("<Left>", self.scroll) #Les fleches scroll la vue
        self.canvas.bind("<Right>", self.scroll)
        self.canvas.bind("<Up>", self.scroll)
        self.canvas.bind("<Down>", self.scroll)
        self.canvas.bind("<Motion>", self.infoMouseOver)
        self.canvas.bind("<r>", self.cacherRessources)

        self.canvas.focus_set() #Place le focus sur le canvas
        self.canvas.configure(yscrollincrement='1')
        self.canvas.configure(xscrollincrement='1')
        self.worldSize = worldSize
        self.offsetX = 0 #Le offset represente le deplacement de la vue dans la map, car les donnees X et Y recues par les methodes sont toujours sur la taille du canvas et non pas de la map en tant que tel
        self.offsetY = 0
        self.offsetXMax = worldSize - width
        self.offsetYMax = worldSize - height
        self.uniteCourante = []
        self.batimentSelectionne = None
        self.affRessources = False
        self.dessinAttaque = []
        self.width = width
        self.height = height
        self.mousePosX = 0
        self.mousePosY = 0
        

        
        self.BackgroundGalaxie = PhotoImage(file="images/galaxie.GIF")
        self.BackgroundSysteme = PhotoImage(file="images/espace.GIF")
        self.BackgroundPlanete = PhotoImage(file="images/planete.GIF")
        self.soleil = PhotoImage(file="images/soleil_systeme.GIF")
        
        
        
        self.listeImagesPlanetes = []
        self.listeImagesPlanetes.append(PhotoImage(file="images/planete1.GIF"))
        self.listeImagesPlanetes.append(PhotoImage(file="images/planete2.GIF"))
        self.listeImagesPlanetes.append(PhotoImage(file="images/planete3.GIF"))
        self.listeImagesPlanetes.append(PhotoImage(file="images/planete4.GIF"))
        self.listeImagesPlanetes.append(PhotoImage(file="images/planete5.GIF"))
        self.listeImagesPlanetes.append(PhotoImage(file="images/planete6.GIF"))
        self.listeImagesPlanetes.append(PhotoImage(file="images/planete7.GIF"))
        
        self.listeImagesEtoiles = []
        self.listeImagesEtoiles.append(PhotoImage(file="images/etoile1.gif"))
        self.listeImagesEtoiles.append(PhotoImage(file="images/etoile2.gif"))
        self.listeImagesEtoiles.append(PhotoImage(file="images/etoile3.gif"))
        self.listeImagesEtoiles.append(PhotoImage(file="images/etoile4.gif"))
        self.listeImagesEtoiles.append(PhotoImage(file="images/etoile5.gif"))


        ### Images des vaisseaux
        self.imageExplorateur = PhotoImage(file="images/vaisseaux/Explorateur.GIF")
        self.imageTransporteur = PhotoImage(file="images/vaisseaux/Transporteur.GIF")
        self.imageColonisateur = PhotoImage(file="images/vaisseaux/Colonisateur.GIF")
        self.imageFregate = PhotoImage(file="images/vaisseaux/Fregate.GIF")
        self.imageCroiseur = PhotoImage(file="images/vaisseaux/Croiseur.GIF")
        
    def cacherRessources(self, event):
        if self.affRessources:
            self.affRessources = False
        else:
            self.affRessources = True
        
    def scroll(self, event): #Methode qui scroll la vue et bouge la minimap
        if(event.keysym == "Right"):
            if(self.offsetX < self.offsetXMax):
                event.widget.xview_scroll(10, UNITS)
                self.offsetX += 10 #Change l'offset
                self.parent.minimap.posX += 1 #Bouge le rectangle de la minimap
                print(self.offsetX)
        elif(event.keysym == "Left"):
            if(self.offsetX > 0):
                event.widget.xview_scroll(-10, UNITS)
                self.offsetX -= 10 #Change l'offset
                self.parent.minimap.posX -= 1 #Bouge le rectangle de la minimap
                print(self.offsetX)
        elif(event.keysym == "Up"):
            if(self.offsetY > 0):
                event.widget.yview_scroll(-10, UNITS)
                self.offsetY -= 10 #Change l'offset
                self.parent.minimap.posY -= 1 #Bouge le rectangle de la minimap
                print(self.offsetY)
        elif(event.keysym == "Down"):
            if(self.offsetY < self.offsetYMax):
                event.widget.yview_scroll(10, UNITS)
                self.offsetY += 10 #Change l'offset
                self.parent.minimap.posY += 1 #Bouge le rectangle de la minimap
                print(self.offsetY)
    
    def recentrer(self, event):
        #on ajoute des valeurs pour avoir deux milieux
        milieuX = self.offsetX
        milieuY = self.offsetY
        
        clicX = event.x - 400
        clicY = event.y - 300
        
        if(clicX > 200 and clicY < 400):
            self.canvas.xview_moveto(200)
            self.canvas.yview_moveto(clicY)
            self.parent.minimap.posX = 20
            self.parent.minimap.posY = clicY / 10    
        
    def carreSelectionDebut(self, event):
        self.selectionDebut = (event.x + self.offsetX, event.y + self.offsetY)
    
    def carreDrag(self, event):
        self.selectionEnCours = (event.x + self.offsetX, event.y + self.offsetY)
        
    def carreSelectionFin(self, event):
        self.selectionEnCours = None #Le drag est termine, donc on remet sa variable a None pour que le carre ne soit pas redessine
        self.selectionFin = (event.x + self.offsetX , event.y + self.offsetY)
        self.selection()

    def selection(self): #Selectionne une unite sur le canvas
        infoSelection = ""

        # Lorsqu'un bâtiment est sélectionné pour la construction, au clic gauche de la souris il sera construit
        ##
        ### CONSTRUCTION
        ##
        #
        if self.parent.hud.choixConstruction != None:
            if(self.vueCourante.typeVue() == "Planete"):
                if self.parent.parent.ressourcesDispo(self.vueCourante.systemeParent.getRessourcesJoueur(), self.parent.hud.choixConstruction.nom, "batiment"):
                    if self.vueCourante.placePourConstruire(self.mousePosX, self.mousePosY, self.parent.hud.choixConstruction.nom, 10):
                        if self.parent.hud.choixConstruction.nom == "Mine":
                            self.parent.parent.creerBatiment(self.vueCourante.systemeParent.ID, self.vueCourante.ID, self.parent.hud.choixConstruction.nom, self.vueCourante.laRessource.posX, self.vueCourante.laRessource.posY, 0)
                        else:
                            self.parent.parent.creerBatiment(self.vueCourante.systemeParent.ID, self.vueCourante.ID, self.parent.hud.choixConstruction.nom, self.mousePosX, self.mousePosY, 0)
                        
            elif(self.vueCourante.typeVue() == "Systeme"):
                if self.parent.parent.ressourcesDispo(self.vueCourante.getRessourcesJoueur(), self.parent.hud.choixConstruction.nom, "batiment"):
                    if self.vueCourante.placePourConstruire(self.mousePosX, self.mousePosY, self.parent.hud.choixConstruction.nom, 10):
                        self.parent.parent.creerBatiment(self.vueCourante.ID, - 1, self.parent.hud.choixConstruction.nom, self.mousePosX, self.mousePosY, 0)
            self.parent.hud.arretPlacerConstruction()
        # 
        ##
        ### Vue Galaxie --> Vue Système
        ##
        #
        self.batimentSelectionne = None
        self.typeSelection = "Unite"  ## par defaut // variables pour la véfication lors d'un déplacement ou une attaque
        
        if self.vueCourante.typeVue() == "Galaxie": #Si dans la galaxie
            for objet in self.vueCourante.listeSystemes:
                idDebut = objet.selection(self.selectionDebut[0], self.selectionDebut[1])
                idFin = objet.selection(self.selectionFin[0], self.selectionFin[1])
                
                if idDebut == idFin and idDebut != - 1:
                    self.parent.vueCourante = objet
                    self.vueCourante = objet
                    if self.parent.hud.frameMilieuLequel == "Construction":
                        self.parent.hud.afficherFrameConstruction()
                        self.parent.hud.arretPlacerConstruction()
                    break
                
        # 
        ##
        ### Vue Système --> Vue Planète
        ##
        #  
        elif self.vueCourante.typeVue() == "Systeme": # si dans la galaxie
            self.uniteCourante = []
            for objet in self.vueCourante.listePlanetes:
                idDebut = objet.selection(self.selectionDebut[0], self.selectionDebut[1])
                idFin = objet.selection(self.selectionFin[0], self.selectionFin[1])
                
                if idDebut == idFin and idDebut != - 1:
                    self.parent.vueCourante = objet
                    self.vueCourante = objet
                    if self.parent.hud.frameMilieuLequel == "Construction":
                        self.parent.hud.afficherFrameConstruction()
                        self.parent.hud.arretPlacerConstruction()
                    break

        # 
        ##
        ### Vue Système ( Target Unité )
        ##
        #  

            for objet in self.vueCourante.listeEntites:
                if(objet.selection(self.selectionDebut, self.selectionFin) == 1 and objet.joueur == self.parent.parent.modele.joueur.nom and objet.typeEntite() == "Unite"):
                    self.uniteCourante.append([objet.nom, objet.id]) #Change l'unite courrante en y ajoutant son nom et son id 
                    self.parent.hud.afficherFrameSelection()
                    self.parent.hud.enleverFrameConstruction()
                    
            if self.uniteCourante:
                if len(self.uniteCourante) == 1:
                    infoSelection = "Unite selectionnee: "
                elif len(self.uniteCourante) > 1:
                    infoSelection = "Unites selectionnees: "
                    
                for unite in self.uniteCourante:
                    infoSelection += unite[0]
                    infoSelection += ", "
                
                infoSelection = infoSelection[: - 2]
                
        # 
        ##
        ### Vue Planète ( Target Unité )
        ##
        #  
        
        elif self.vueCourante.typeVue() == "Planete":
            self.uniteCourante = []
            
            for objet in self.vueCourante.listeEntites:
                if(objet.selection(self.selectionDebut, self.selectionFin) == 1 and objet.joueur == self.parent.parent.modele.joueur.nom and objet.typeEntite() == "Unite"):
                    self.uniteCourante.append([objet.nom, objet.id]) #Change l'unite courrante en y ajoutant son nom et son id 
                    self.parent.hud.afficherFrameSelection()
                    self.parent.hud.enleverFrameConstruction()
            if self.uniteCourante:
                if len(self.uniteCourante) == 1:
                    infoSelection = "Unite selectionnee: "
                elif len(self.uniteCourante) > 1:
                    infoSelection = "Unites selectionnees: "
                    
                for unite in self.uniteCourante:
                    infoSelection += unite[0]
                    infoSelection += ", "
                
                infoSelection = infoSelection[: - 2]
                self.parent.hud.afficherMenuEntite()
            
        # 
        ##
        ### Vue Planète et Vue Système ( Target 1 batiment )
        ##
        #  
        if len(self.uniteCourante) == 0:
            for objet in self.vueCourante.listeEntites:
                if(objet.selection(self.selectionDebut, self.selectionFin) == 1 and objet.joueur == self.parent.parent.modele.joueur.nom and objet.typeEntite() == "Batiment"):
                    self.uniteCourante.append([objet.nom, objet.id]) #Change l'unite courrante en y ajoutant son nom et son id 
                    self.parent.hud.afficherFrameSelection()
            if self.uniteCourante:
                if len(self.uniteCourante) == 1:
                    infoSelection = "Unite selectionnee: "
                elif len(self.uniteCourante) > 1:
                    infoSelection = "Unites selectionnees: "
                    
                for unite in self.uniteCourante:
                    infoSelection += unite[0]
                    infoSelection += ", "
                
                infoSelection = infoSelection[: - 2]
                
            if len(self.uniteCourante) == 1:
                #if self.uniteCourante[0].typeEntite()=="Batiment":
                self.typeSelection = "Batiment"       ##  variables pour la véfication lors d'un déplacement ou une attaque
                if self.uniteCourante[0][0] == "Caserne":
                    #if self.vueCourante.trouverEntiteParId(self.uniteCourante[0][1]).nom=="Caserne":
                    self.batimentSelectionne = "Caserne"
                    self.parent.hud.afficherFrameConstruction()
            else:
                self.uniteCourante = []
                self.typeSelection = "Batiment"
                self.batimentSelectionne = None
    
    def constructionUnitePlanete(self, unite):
        leBatiment = self.vueCourante.trouverEntiteParId(self.uniteCourante[0][1])
        self.parent.parent.creerUnite(self.vueCourante.systemeParent.ID, self.vueCourante.ID, unite.nom, leBatiment.posX , leBatiment.posY, 0, leBatiment.rallyX, leBatiment.rallyY, 0)
        
    def action(self, event): 
        modeAttaque = False
        
        
        if self.uniteCourante[0][0] == "Caserne":
            (self.vueCourante.trouverEntiteParId(self.uniteCourante[0][1]))
                

        # cancel le choix de construction en cours
        if self.parent.hud.choixConstruction != None:
            self.parent.hud.arretPlacerConstruction()

        
        if(self.uniteCourante)and self.typeSelection == "Unite":  #S'il y a des unites selectionnees
            self.clicEnCours = 10
            self.clicEnCoursX = event.x + self.offsetX
            self.clicEnCoursY = event.y + self.offsetY
        
            for objet in self.vueCourante.listeEntites:
                tuplePositionSouris = (event.x + self.offsetX, event.y + self.offsetY)
                
                #Vérifie si on clique sur l'une de nos unités
                if(objet.selection(tuplePositionSouris, tuplePositionSouris) == 1 
                   and objet.joueur != self.parent.parent.modele.joueur.nom):
                    #Vérifie si on clique sur un allie
                    if(self.parent.parent.verifierStatus(objet.joueur) == True):
                        for unite in self.uniteCourante:
                            self.parent.parent.attaquerUnite(unite[1], objet.id, self.vueCourante.ID, self.vueCourante.systemeParent.ID)
                            modeAttaque = True
                if not modeAttaque:
                    for unite in self.uniteCourante:
                        if self.vueCourante.typeVue() == "Planete":
                            self.parent.parent.deplacerUnite(unite[1], self.vueCourante.ID, self.vueCourante.systemeParent.ID, event.x + self.offsetX, event.y + self.offsetY, 0)
                        elif self.vueCourante.typeVue() == "Systeme":
                            for objet in self.vueCourante.listePlanetes:
                                self.selectionDebut = (event.x + self.offsetX, event.y + self.offsetY)
                                self.selectionFin = (event.x + self.offsetX, event.y + self.offsetY)
                                idDebut = objet.selection(self.selectionDebut[0], self.selectionDebut[1])
                                idFin = objet.selection(self.selectionFin[0], self.selectionFin[1])
                                if idDebut == idFin and idDebut != - 1: #Action sur une planete
                                    self.parent.parent.entrerUnitePlanete(self.uniteCourante, self.vueCourante.ID, objet.ID)
                                    break
                                else: #Action dans le vide
                                    self.parent.parent.deplacerUnite(unite[1], - 1, self.vueCourante.ID, event.x + self.offsetX, event.y + self.offsetY, 0)
            
    def redraw(self): #Redessine le canvas; plus utile que de bouger les objets sur le canvas!!
        self.canvas.delete(ALL) #Efface tout ce qui etait affichÃƒÂ©
        self.vueCourante = self.parent.vueCourante
        
        if self.vueCourante.typeVue() == "Galaxie":
            self.canvas.create_image(500, 500, image=self.BackgroundGalaxie)
            for systeme in self.vueCourante.listeSystemes:
                #self.canvas.create_image(systeme.posX - systeme.dimX / 2+26, systeme.posY - systeme.dimY / 2+26, image=self.planete1)
                #self.canvas.create_oval(systeme.posX - systeme.dimX / 2, systeme.posY - systeme.dimY / 2, systeme.posX + systeme.dimX / 2, systeme.posY + systeme.dimY / 2, fill="yellow")
                self.canvas.create_image(systeme.posX - systeme.dimX / 2 + 26, systeme.posY - systeme.dimY / 2 + 26, image=self.listeImagesEtoiles[systeme.indexImageEtoile])
                self.canvas.create_text(systeme.posX, systeme.posY + systeme.dimY / 2 + 12, text=systeme.nom, fill="white")
                
        elif self.vueCourante.typeVue() == "Systeme":
            self.canvas.create_image(500, 500, image=self.BackgroundSysteme)
            self.canvas.create_image(500, 500, image=self.soleil)
            self.canvas.create_text(self.worldSize / 2 + 12, self.worldSize / 2 + 52, text=self.vueCourante.nom, fill="white")
            for planete in self.vueCourante.listePlanetes:
                
                self.canvas.create_image(planete.posX - planete.dimX / 2 + 26, planete.posY - planete.dimY / 2 + 26, image=self.listeImagesPlanetes[planete.indexImagePlanete])
                #self.canvas.create_oval(planete.posX - planete.dimX / 2, planete.posY - planete.dimY / 2, planete.posX + planete.dimX / 2, planete.posY + planete.dimY / 2, fill="blue")
                self.canvas.create_text(planete.posX, planete.posY + planete.dimY / 2 + 12, text=planete.nom, fill="white")
        else:
            self.canvas.create_image(500, 500, image=self.BackgroundPlanete)
            if self.affRessources:
                for ressource in self.vueCourante.listeRessources:
                    if ressource.type == "titane": #Parcours les ressources et les affiche
						#http://effbot.org/tkinterbook/canvas.htm
                        lol = self.canvas.create_rectangle(ressource.posX - ressource.size / 2, ressource.posY - ressource.size / 2, ressource.posX + ressource.size / 2, ressource.posY + ressource.size / 2, fill=ressource.couleur, outline="black")
                        self.canvas.itemconfig(lol, tags="test")
                        print("Longueur: " + str(len(self.canvas.find_withtag("test"))))
                    else:
                        self.canvas.create_rectangle(ressource.posX - ressource.size / 2, ressource.posY - ressource.size / 2, ressource.posX + ressource.size / 2, ressource.posY + ressource.size / 2, fill=ressource.couleur, outline="white")

            
            if self.dessinAttaque:
                for i in reversed(range(len(self.dessinAttaque))): #Parcours de la liste a partir de la fin, comme ca quand on delete des items on peut continuer d'iterer la liste sans que les elements changent d'index
                    self.canvas.create_line(self.dessinAttaque[i][0][0], self.dessinAttaque[i][0][1], self.dessinAttaque[i][1][0], self.dessinAttaque[i][1][1], fill="red", width=2)
                    self.dessinAttaque[i][2] = self.dessinAttaque[i][2] - 1
                    
                    if self.dessinAttaque[i][2] <= 0:
                        del self.dessinAttaque[i]
                        
        #On recupere la liste de couleur sur le serveur. Lindice du joueur dans la liste de joueur est egal
        #a lindice de la couleur dans la liste de couleurs
        self.listeCouleurs = self.parent.parent.retournerListeCouleursJoueurs()
        self.listeJoueurs = self.parent.parent.creeListeJoueurs()
#####################################  Dessine les BATIMENTS et UNITÉS + barres de vies + carrées de sélections
##################################### 
        for objet in self.vueCourante.listeEntites: #Liste d'entite
            if objet.typeEntite() == "Unite" or objet.typeEntite() == "Batiment":
                pourcentageVie = int((objet.nbrVies / objet.vies_max) * 100)      # calcule la vie restante a l'unitÃ©
                longueurBar = objet.dimX * (pourcentageVie / 100)  
                    
                #on va chercher lindice du joueur en allant chercher le nom du joueur dans lunitee
                #on va ensuite chercher lindex en utilisant la methode index()
                
                self.laCouleur = self.listeCouleurs[self.listeJoueurs.index(objet.joueur)]
                #self.laCouleur = self.listeCouleurs[self.parent.parent.joueurs.index(objet.joueur)]
                    
                if self.uniteCourante:
                    uniteTrouvee = False
                        
                    for unite in self.uniteCourante:
                        if objet.id == unite[1]:
                            if objet.typeEntite() == "Unite":
                                self.canvas.create_rectangle(objet.posX - objet.dimX / 2, objet.posY - objet.dimY / 2, objet.posX + objet.dimX / 2, objet.posY + objet.dimY / 2, fill=None, outline="green", width=5)
                            elif objet.typeEntite() == "Batiment":
                                self.canvas.create_rectangle(objet.posX - objet.dimX / 2, objet.posY - objet.dimY / 2, objet.posX + objet.dimX / 2, objet.posY + objet.dimY / 2, fill=None, outline="green", width=5)
                            uniteTrouvee = True
                            break          
##                        if not uniteTrouvee and objet.typeEntite()=="Unite":
##                            if objet.image:
##                                self.canvas.create_image(objet.posX, objet.posY,image=objet.image)
##                            else:
##                                self.canvas.create_rectangle(objet.posX - objet.dimX / 2, objet.posY - objet.dimY / 2, objet.posX + objet.dimX / 2, objet.posY + objet.dimY / 2, fill=self.laCouleur)
##                elif objet.typeEntite()=="Unite":
##                    if objet.image:
##                        self.canvas.create_image(objet.posX, objet.posY,image=objet.image)
##                    else:
##                        self.canvas.create_rectangle(objet.posX - objet.dimX / 2, objet.posY - objet.dimY / 2, objet.posX + objet.dimX / 2, objet.posY + objet.dimY / 2, fill=self.laCouleur) 
                     
                #Petit if-else rapide pour mettre la barre de vie en vert, jaune ou rouge selon la vie restante
                if pourcentageVie > 25 and pourcentageVie <= 50:   
                    self.canvas.create_rectangle(objet.posX - longueurBar / 2, objet.posY + objet.dimY / 2 + 2, objet.posX + longueurBar / 2, objet.posY + objet.dimY / 2 + 8, fill="yellow") # AJOUTE LA BAR DE VIE AUX UNITÃƒâ€°S
                elif pourcentageVie <= 25:
                    self.canvas.create_rectangle(objet.posX - longueurBar / 2, objet.posY + objet.dimY / 2 + 2, objet.posX + longueurBar / 2, objet.posY + objet.dimY / 2 + 8, fill="red")
                else:
                    self.canvas.create_rectangle(objet.posX - longueurBar / 2, objet.posY + objet.dimY / 2 + 2, objet.posX + longueurBar / 2, objet.posY + objet.dimY / 2 + 8, fill="green")
        
        
                if self.selectionEnCours:
                    self.canvas.create_rectangle(self.selectionDebut[0], self.selectionDebut[1], self.selectionEnCours[0], self.selectionEnCours[1], outline="green")


                
            #if objet.typeEntite()=="Batiment":
            if objet.image:
                self.canvas.create_image(objet.posX, objet.posY, image=objet.image)
            else:
                self.canvas.create_rectangle(objet.posX - objet.dimX / 2, objet.posY - objet.dimY / 2, objet.posX + objet.dimX / 2, objet.posY + objet.dimY / 2, fill=self.laCouleur)
                #self.canvas.create_rectangle(objet.posX - objet.dimX / 2, objet.posY - objet.dimY / 2, objet.posX + objet.dimX / 2, objet.posY + objet.dimY / 2, fill="yellow")  
###############################################################################################################  



#####################################       
#####################################    Zone verte/rouge lors d'une construction
        if self.parent.hud.choixConstruction != None:
            if self.vueCourante.placePourConstruire(self.mousePosX, self.mousePosY, self.parent.hud.choixConstruction.nom, 0) == True:
                self.canvas.create_rectangle(self.mousePosX - 30, self.mousePosY - 30, self.mousePosX + 30, self.mousePosY + 30, fill="green")
                self.canvas.create_image(self.mousePosX, self.mousePosY, image=self.parent.hud.choixConstruction.image)
            else:
                self.canvas.create_rectangle(self.mousePosX - 30, self.mousePosY - 30, self.mousePosX + 30, self.mousePosY + 30, fill="red")
                self.canvas.create_image(self.mousePosX, self.mousePosY, image=self.parent.hud.choixConstruction.image)
###############################################################################################################     



#####################################   Petit Rond lors d'un déplacement / d'une attaque
#####################################
        if self.clicEnCours:
            self.clicEnCours = self.clicEnCours - 1
            self.canvas.create_oval(self.clicEnCoursX - 1, self.clicEnCoursY - 1, self.clicEnCoursX + 1, self.clicEnCoursY + 1, outline="green", width=2)
            self.canvas.create_oval(self.clicEnCoursX - 10, self.clicEnCoursY - 10, self.clicEnCoursX + 10, self.clicEnCoursY + 10, outline="green", width=2)
############################################################################################################### 
        
    def infoMouseOver(self, event): #Envoi les infos des objets sous le curseur au HUD
        infoRes = ""
        infoUnit = ""
        
        if self.vueCourante.typeVue() == "Planete": #or self.vueCourante.typeVue() =="Systeme":  Parcours les ressources sous lemplacement de la souris
            if self.affRessources:
                if(self.vueCourante.ressourceTerrainSelectionne(event.x + self.offsetX, event.y + self.offsetY) != None):
                    infoRes += "Ressource: "
                    infoRes += self.vueCourante.ressourceTerrainSelectionne(event.x + self.offsetX, event.y + self.offsetY)
            
            for objet in self.vueCourante.listeEntites: #Parcours les entites sous la souris
                tuplePositionSouris = (event.x + self.offsetX, event.y + self.offsetY)
                
                if(objet.selection(tuplePositionSouris, tuplePositionSouris) == 1 and objet.joueur != self.parent.parent.modele.joueur.nom):
                    infoUnit += "Unite: "
                    infoUnit += objet.nom
                    infoUnit += " enemi " + "qui appartient a " + objet.joueur
                    break
                elif(objet.selection(tuplePositionSouris, tuplePositionSouris)):
                    infoUnit += "Unite: "
                    infoUnit += objet.nom
                    break
        self.mousePosX = event.x + self.offsetX
        self.mousePosY = event.y + self.offsetY
			#Envoi des infos au HUD
            #self.parent.hud.infoRes.config(text=infoRes)
            #self.parent.hud.infoUnit.config(text=infoUnit)

                
    
    def getAffRessources(self):
        return self.affRessources
    
class Hud():
    def __init__(self, parent, frame, width, height, worldSize):
        self.parent = parent
        self.worldSize = worldSize
        self.width = width
        self.height = height
        self.minimapSize = 100
        self.minimapRatio = int(self.worldSize / self.minimapSize) #Combien de fois plus petite est la minimap par rapport au monde
        self.frame = Frame(frame, width=width, height=height, background="black", relief=RIDGE, borderwidth=10) #Le frame noir du HUD comme tel
        self.frame.pack(side=BOTTOM)#, fill=BOTH)


        self.bouttonRetour = Button(self.frame, text="Retour", bg="blue", fg="white", borderwidth=3, relief=RIDGE, command=self.parent.retourVue)
        self.bouttonRetour.pack(side=LEFT, fill=Y)
        self.canvas = Canvas(self.frame, width=self.minimapSize, height=self.minimapSize, background="black", relief=RIDGE, borderwidth=0) #La minimap
        self.canvas.pack(side=LEFT)
        self.canvas.bind("<Button-1>", self.deplacerParLaMAP)
        self.canvas.bind("<B1-Motion>", self.deplacerParLaMAP)
        self.canvas.bind("<Button-3>", self.deplacerUnitesParLaMAP)
        #self.hint = Label(self.frame, text="Les fleches du clavier font scroller la vue.", fg="white", bg="black")
        #self.hint.pack()
        #self.infoRes = Label(self.frame, fg="white", bg="black") #Les champs d'infos, vides a la base
        #self.infoRes.pack()
        #self.infoUnit = Label(self.frame, fg="white", bg="black")
        #self.infoUnit.pack()
        #self.infoSelection = Label(self.frame, fg="white", bg="black")
        #self.infoSelection.pack()
        self.frameMilieuLequel = ""
        #elements du menu
        self.menu = Frame(self.frame, width=200, height=140, background="blue", relief=RIDGE, borderwidth=3)
        self.menu.pack(side=RIGHT, fill=Y, expand=1)
        self.menu.propagate(0)
        
        
        self.boutonsActionUnites = Frame(self.frame, width=200, height=140, background="blue", relief=RIDGE, borderwidth=3)
        
        #self.boutonAttaque = Button(self.boutonActionUnites, text="Attaque")
        #self.boutonStop = Button(self.boutonActionUnites, text="Stop")
        #self.boutonSysteme = Button(self.boutonActionUnites, text="Sortir de la planete", command=lambda:self.parent.parent.sortirUnitePlanete(self.parent.canvas.uniteCourante, self.parent.vueCourante.systemeParent.ID, self.parent.vueCourante.ID))
        self.dessine = False
        
        
        
        #self.boutonSysteme.pack()
        #frame milieu 
        self.frameMilieu = Frame(self.frame, width=450, height=140, background="black", borderwidth=2, relief=FLAT)
        self.frameMilieu.pack(side=LEFT, fill=BOTH)
        self.frameMilieu.propagate(0)
        #fin frame milieu


        self.choixConstruction = None
        # boutons pour changer entre le chat et la sélections des unités
        self.iconeChat = PhotoImage(file="images/iconeChat.GIF")
        self.iconeSelection = PhotoImage(file="images/iconeSelection.GIF")
        self.iconeConstruction = PhotoImage(file="images/iconeConstruction.GIF")



## ICONES pour menus de construction
        
        ###  Images des batiments
        #
        #
        self.iconeMine = PhotoImage(file="images/Mine.GIF")
        self.iconeHabitation = PhotoImage(file="images/Habitation.GIF")
        self.iconeUsine = PhotoImage(file="images/usine.GIF")

        self.iconeCentreCommunication = PhotoImage(file="images/centreCommunication.GIF")
        self.iconeCentreRecherche = PhotoImage(file="images/centreRecherche.GIF")
        self.iconeTour = PhotoImage(file="images/Tour.GIF")
        
        self.iconeStationSpatiale = PhotoImage(file="images/StationSpatiale.GIF")
        # 
        #
        ###


        ###  Images des vaisseaux
        #
        #
        self.iconeExplorateur = PhotoImage(file="images/vaisseaux/IconeExplorateur.GIF")
        self.iconeTransporteur = PhotoImage(file="images/vaisseaux/IconeTransporteur.GIF")
        self.iconeColonisateur = PhotoImage(file="images/vaisseaux/IconeColonisateur.GIF")
        self.iconeFregate = PhotoImage(file="images/vaisseaux/IconeFregate.GIF")
        self.iconeCroiseur = PhotoImage(file="images/vaisseaux/IconeCroiseur.GIF")
        # 
        #
        ###
##
        
        self.frameMilieuBoutons = Frame(self.frame, width=60, background="black", borderwidth=2, relief=FLAT)
        self.frameMilieuBoutons.pack(side=LEFT, fill=Y, expand=1)
        
        
        self.boutonVueChat = Button(self.frameMilieuBoutons, text="" , image=self.iconeChat, command=self.afficherFrameChat)
        self.boutonVueChat.pack()
        createToolTip(self.boutonVueChat, "Chat")
        self.boutonVueUnites = Button(self.frameMilieuBoutons, text="", image=self.iconeSelection, command=self.afficherFrameSelection)
        self.boutonVueUnites.pack()
        createToolTip(self.boutonVueUnites, "Unité(s) sélectionné(s)")
        self.boutonVueConstruction = Button(self.frameMilieuBoutons, text="", image=self.iconeConstruction, command=self.afficherFrameConstruction)
        self.boutonVueConstruction.pack()
        createToolTip(self.boutonVueConstruction, "Construction")
        
        
        self.vueChat = Frame(self.frameMilieu, width=450, height=130, background="grey", borderwidth=2, relief=FLAT)
        self.vueSelection = Frame(self.frameMilieu, width=450, height=130, background="grey", borderwidth=2, relief=FLAT)
        
        self.vueConstruction = Frame(self.frameMilieu, width=200, height=130, background="grey", borderwidth=2, relief=FLAT)
        self.vueCreationUnite = Frame(self.frameMilieu, width=200, height=130, background="grey", borderwidth=2, relief=FLAT)
        
        self.afficherFrameChat()
        
        self.vueCourante = self.parent.vueCourante


    def afficherFrameCreationUnite(self):
        self.frameMilieuLequel = "CreationUnite"

    def enleverFrameConstruction(self):
        self.vueConstruction.forget()
        self.arretPlacerConstruction()
    
    def afficherFrameConstruction(self):
        self.frameMilieuLequel = "Construction"
        
        self.menu.destroy()
        self.menu = Frame(self.frame, width=200, height=120, background="blue", relief=RIDGE, borderwidth=3)
        self.menu.pack(side=RIGHT, fill=Y)
        self.menu.propagate(0)
        
        #self.vueSelection.forget()
        #self.vueChat.forget()
        self.vueConstruction.destroy()
        self.arretPlacerConstruction()
        
        self.vueConstruction = Frame(self.menu, width=200, height=120, background="blue", borderwidth=2, relief=FLAT)
        self.vueConstruction.pack(side=LEFT, fill=BOTH)
        self.vueConstruction.propagate(0)
        

        # Construction possible dans une Caserne
        if self.parent.canvas.batimentSelectionne == "Caserne":
            # Explorateur
            self.boutonConstruireExplorateur = Button(self.vueConstruction, bg="white", text="Explorateur", image=self.iconeExplorateur, command=lambda:self.parent.canvas.constructionUnitePlanete(self.boutonConstruireExplorateur))
            self.boutonConstruireExplorateur.grid(row=0, column=0)
            #self.boutonConstruireExplorateur.pack(side=LEFT)
            self.boutonConstruireExplorateur.image = self.iconeExplorateur
            self.boutonConstruireExplorateur.nom = "Explorateur"
            createToolTip(self.boutonConstruireExplorateur, "Explorateur")
            # Transporteur
            self.boutonConstruireTransporteur = Button(self.vueConstruction, bg="white", text="Transporteur", image=self.iconeTransporteur, command=lambda:self.parent.canvas.constructionUnitePlanete(self.boutonConstruireTransporteur))
            self.boutonConstruireTransporteur.grid(row=0, column=1)
            #self.boutonConstruireTransporteur.pack(side=LEFT)
            self.boutonConstruireTransporteur.image = self.iconeTransporteur
            self.boutonConstruireTransporteur.nom = "Transporteur"
            createToolTip(self.boutonConstruireTransporteur, "Transporteur")
            # Colonisateur
            self.boutonConstruireColonisateur = Button(self.vueConstruction, bg="white", text="Colonisateur", image=self.iconeColonisateur, command=lambda:self.parent.canvas.constructionUnitePlanete(self.boutonConstruireColonisateur))
            self.boutonConstruireColonisateur.grid(row=0, column=2)
            #self.boutonConstruireColonisateur.pack(side=LEFT)
            self.boutonConstruireColonisateur.image = self.iconeColonisateur
            self.boutonConstruireColonisateur.nom = "Colonisateur"
            createToolTip(self.boutonConstruireColonisateur, "Colonisateur")
            # Fregate
            self.boutonConstruireFregate = Button(self.vueConstruction, bg="white", text="Fregate", image=self.iconeFregate, command=lambda:self.parent.canvas.constructionUnitePlanete(self.boutonConstruireFregate))
            self.boutonConstruireFregate.grid(row=1, column=0)
            #self.boutonConstruireFregate.pack(side=LEFT)
            self.boutonConstruireFregate.image = self.iconeFregate
            self.boutonConstruireFregate.nom = "Fregate"
            createToolTip(self.boutonConstruireFregate, "Fregate")
            # Croiseur
            self.boutonConstruireCroiseur = Button(self.vueConstruction, bg="white", text="Croiseur", image=self.iconeCroiseur, command=lambda:self.parent.canvas.constructionUnitePlanete(self.boutonConstruireCroiseur))
            self.boutonConstruireCroiseur.grid(row=1, column=1)
            #self.boutonConstruireCroiseur.pack(side=LEFT)
            self.boutonConstruireCroiseur.image = self.iconeCroiseur
            self.boutonConstruireCroiseur.nom = "Croiseur"
            createToolTip(self.boutonConstruireCroiseur, "Croiseur")


        # Construction possible sur une planète
        elif self.parent.vueCourante.typeVue() == "Planete":
            # Mine
            self.boutonConstruireMine = Button(self.vueConstruction, bg="white", text="Mine", image=self.iconeMine, command=lambda:self.placerConstruction(self.boutonConstruireMine))
            self.boutonConstruireMine.grid(row=0, column=0)
            #self.boutonConstruireMine.pack(side=LEFT)
            self.boutonConstruireMine.image = self.iconeMine
            self.boutonConstruireMine.nom = "Mine"
            createToolTip(self.boutonConstruireMine, "Mine")
            # Habitation
            self.boutonConstruireHabitation = Button(self.vueConstruction, bg="white", text="Habitation", image=self.iconeHabitation, command=lambda:self.placerConstruction(self.boutonConstruireHabitation))
            self.boutonConstruireHabitation.grid(row=0, column=1)
            #self.boutonConstruireHabitation.pack(side=LEFT)
            self.boutonConstruireHabitation.image = self.iconeHabitation
            self.boutonConstruireHabitation.nom = "Habitation"
            createToolTip(self.boutonConstruireHabitation, "Habitation")
            # Caserne
            self.boutonConstruireCaserne = Button(self.vueConstruction, bg="white", text="Caserne", image=self.iconeUsine, command=lambda:self.placerConstruction(self.boutonConstruireCaserne))
            self.boutonConstruireCaserne.grid(row=0, column=2)
            #self.boutonConstruireCaserne.pack(side=LEFT)
            self.boutonConstruireCaserne.image = self.iconeUsine
            self.boutonConstruireCaserne.nom = "Caserne"
            createToolTip(self.boutonConstruireCaserne, "Caserne")
            
            # Centre de recherche
            self.boutonConstruireCentreRecherche = Button(self.vueConstruction, bg="white", text="Centre Recherche", image=self.iconeCentreRecherche, command=lambda:self.placerConstruction(self.boutonConstruireCentreRecherche))
            self.boutonConstruireCentreRecherche.grid(row=1, column=0)
            #self.boutonConstruireCentreRecherche.pack(side=LEFT)
            self.boutonConstruireCentreRecherche.image = self.iconeCentreRecherche
            self.boutonConstruireCentreRecherche.nom = "Centre de Recherche"
            createToolTip(self.boutonConstruireCentreRecherche, "Centre de Recherche")
            # centre de communication
            self.boutonConstruireCentreCommunication = Button(self.vueConstruction, bg="white", text="Centre de Communication", image=self.iconeCentreCommunication, command=lambda:self.placerConstruction(self.boutonConstruireCentreCommunication))
            self.boutonConstruireCentreCommunication.grid(row=1, column=1)
            #self.boutonConstruireCentreCommunication.pack(side=LEFT)
            self.boutonConstruireCentreCommunication.image = self.iconeCentreCommunication
            self.boutonConstruireCentreCommunication.nom = "Centre de Communication"
            createToolTip(self.boutonConstruireCentreCommunication, "Centre de Communication")
            # tour de défense      simon:défense prend un s noob !
            self.boutonConstruireTour = Button(self.vueConstruction, bg="white", text="Tour de défense", image=self.iconeTour, command=lambda:self.placerConstruction(self.boutonConstruireTour))
            self.boutonConstruireTour.grid(row=1, column=2)
            #self.boutonConstruireTour.pack(side=LEFT)
            self.boutonConstruireTour.image = self.iconeTour
            self.boutonConstruireTour.nom = "Tour"
            createToolTip(self.boutonConstruireTour, "Tour de Défense")
        # Construction dans un systèmes solaires
        
        elif self.parent.vueCourante.typeVue() == "Systeme":
            # base spatiale
            self.boutonConstruireBaseSpatiale = Button(self.vueConstruction, bg="white", text="Station spatiale", image=self.iconeStationSpatiale, command=lambda:self.placerConstruction(self.boutonConstruireBaseSpatiale))
            self.boutonConstruireBaseSpatiale.grid(row=0, column=0)
            #self.boutonConstruireBaseSpatiale.pack(side=LEFT)
            self.boutonConstruireBaseSpatiale.image = self.iconeStationSpatiale
            self.boutonConstruireBaseSpatiale.nom = "Station Spatiale"
            createToolTip(self.boutonConstruireBaseSpatiale, "Station Spatiale")
            
            # tour de défence spatiale
            #self.boutonConstruireTourSpatiale=Button(self.vueConstruction, text="Tour de défence spatiale")
            #self.boutonConstruireTourSpatiale.pack(side=LEFT)
            #createToolTip(self.boutonConstruireMine, "Tour de Défence Spatiale")
            
        #if self.vueCourante.typeVue() == "Galaxie":
            
    def placerConstruction(self, batiment):
        if self.choixConstruction != None:
            self.arretPlacerConstruction()
        self.choixConstruction = batiment
        self.choixConstruction.configure(bg="blue")

    def arretPlacerConstruction(self):
        if self.choixConstruction != None:
            self.choixConstruction.configure(bg="white")
        self.choixConstruction = None
    def creerUnite(self):
        self, systemeId, planeteId, typeUnite, posX, posY, posZ, rallyX, rallyY, rallyZ
        

    def afficherFrameSelection(self):
        self.frameMilieuLequel = "Selection"
        self.vueChat.forget()
        #self.vueConstruction.forget()
        #self.arretPlacerConstruction()
        self.nombreSelections = 0
        self.vaisseauI = PhotoImage(file="images/vaisseau.gif")
        self.tankI = PhotoImage(file="images/tank.gif")
        
            
    def redessinerUniteSelectionne(self):
        self.vueSelection.destroy()
        self.vueSelection = Frame(self.frameMilieu, width=450, height=120, background="black", borderwidth=2, relief=FLAT)
        for unite in self.parent.canvas.uniteCourante:
            if "Tank" in unite[0]:
                self.bouton = Button(self.vueSelection, image=self.tankI)
                self.bouton.pack(side=LEFT, anchor=N)
                self.bouton.unite = unite
                self.bouton.bind("<Button-1>", self.selectionnerUneUnite)#lambda e:self.selectionnerUneUnite(unite[0],unite[1]))
            else:
                self.bouton = Button(self.vueSelection, image=self.vaisseauI)
                self.bouton.pack(side=LEFT, anchor=N)
                self.bouton.unite = unite
                self.bouton.bind("<Button-1>", self.selectionnerUneUnite)#e:self.selectionnerUneUnite(unite[0],unite[1]))
        
        self.vueSelection.pack(side=LEFT, fill=BOTH)
        self.vueSelection.propagate(0)
        self.nombreSelections = len(self.parent.canvas.uniteCourante)
        print("redessine")
    
    def selectionnerUneUnite(self, e):
        unite = e.widget.unite
        nom = unite[0]
        id = unite[1]
        self.parent.canvas.uniteCourante = []
        self.parent.canvas.uniteCourante.append([nom, id])
        self.afficherMenuEntite()
        
    def afficherFrameChat(self):
        self.frameMilieuLequel = "Chat"
        self.vueSelection.forget()
        #self.vueConstruction.forget()
        #self.arretPlacerConstruction()
        
        self.vueChat.pack(side=LEFT, fill=BOTH, expand=1)
        
        self.textChat = Text(self.vueChat, width=50, height=5)
        self.textChat.grid(row=1, column=0, sticky=W)
        
        self.entreChat = Entry(self.vueChat, width=50)
        self.entreChat.grid(row=5, column=0, sticky=W)
        self.parent.canvas.canvas.focus_set()
        
        self.vueChat.bind_all("<Return>", lambda insertionTexte: self.parent.insererTexteChat(self.entreChat.get(), True))
     
    def raffraichirChat(self):
        self.leTexte = ""
        self.listeChat = self.parent.parent.creeListeChat()
        self.textChat.delete(1.0, END)
        
        for texte in self.listeChat:
            self.leTexte += texte + "\n"
            
        self.textChat.insert(END, self.leTexte)
        self.textChat.see(END)
          
        self.leTexte = ""   
    
    def redraw(self): #Exactement le meme fonctionnement que l'interface, mais plus petit, car c'est pour la minimap
        self.raffraichirChat()
        self.canvas.delete(ALL)
        self.canvas.create_rectangle(self.parent.minimap.posX, self.parent.minimap.posY, (self.parent.minimap.posX + int(self.width / self.minimapRatio)), (self.parent.minimap.posY + int(self.height / self.minimapRatio)), outline="brown")
        self.vueCourante = self.parent.vueCourante
        
        if self.parent.canvas.getAffRessources():
            for ressource in self.vueCourante.listeRessources:
                # besoin d'une condition pour le pétrole depuis que le fond de la minimap est noir
                if ressource.type == "petrole":
                    self.canvas.create_rectangle((ressource.posX) / self.minimapRatio - (10 / self.minimapRatio), (ressource.posY) / self.minimapRatio - (10 / self.minimapRatio), (ressource.posX) / self.minimapRatio + (10 / self.minimapRatio), (ressource.posY) / self.minimapRatio + (10 / self.minimapRatio), outline="white" , fill=ressource.couleur)

                else:    
                    self.canvas.create_rectangle((ressource.posX) / self.minimapRatio - (10 / self.minimapRatio), (ressource.posY) / self.minimapRatio - (10 / self.minimapRatio), (ressource.posX) / self.minimapRatio + (10 / self.minimapRatio), (ressource.posY) / self.minimapRatio + (10 / self.minimapRatio), outline=ressource.couleur , fill=ressource.couleur)
        
         
        
        for objet in self.vueCourante.listeEntites:
            self.listeCouleurs = self.parent.parent.retournerListeCouleursJoueurs()
            self.laCouleur = self.listeCouleurs[self.parent.parent.creeListeJoueurs().index(objet.joueur)]
             
            if self.parent.canvas.uniteCourante:
                uniteTrouvee = False
                
                for unite in self.parent.canvas.uniteCourante:
                    if objet.id == unite[1]:
                        self.canvas.create_rectangle(objet.posX / self.minimapRatio - objet.dimX / self.minimapRatio / 2, objet.posY / self.minimapRatio - objet.dimY / self.minimapRatio / 2, objet.posX / self.minimapRatio + objet.dimX / self.minimapRatio / 2, objet.posY / self.minimapRatio + objet.dimY / self.minimapRatio / 2, fill=self.laCouleur, outline="green")
                        uniteTrouvee = True
                        break
                if not uniteTrouvee:
                    self.canvas.create_rectangle(objet.posX / self.minimapRatio - objet.dimX / self.minimapRatio / 2, objet.posY / self.minimapRatio - objet.dimY / self.minimapRatio / 2, objet.posX / self.minimapRatio + objet.dimX / self.minimapRatio / 2, objet.posY / self.minimapRatio + objet.dimY / self.minimapRatio / 2, fill=self.laCouleur)
            else:
                self.canvas.create_rectangle(objet.posX / self.minimapRatio - objet.dimX / self.minimapRatio / 2, objet.posY / self.minimapRatio - objet.dimY / self.minimapRatio / 2, objet.posX / self.minimapRatio + objet.dimX / self.minimapRatio / 2, objet.posY / self.minimapRatio + objet.dimY / self.minimapRatio / 2, fill=self.laCouleur)
                
        if self.vueCourante.typeVue() == "Galaxie":
            for objet in self.vueCourante.listeSystemes:
                self.canvas.create_oval(objet.posX / self.minimapRatio - objet.dimX / self.minimapRatio / 2, objet.posY / self.minimapRatio - objet.dimY / self.minimapRatio / 2, objet.posX / self.minimapRatio + objet.dimX / self.minimapRatio / 2, objet.posY / self.minimapRatio + objet.dimY / self.minimapRatio / 2, fill="yellow")
        if self.vueCourante.typeVue() == "Systeme":
            for objet in self.vueCourante.listePlanetes:
                self.canvas.create_oval(objet.posX / self.minimapRatio - objet.dimX / self.minimapRatio / 2, objet.posY / self.minimapRatio - objet.dimY / self.minimapRatio / 2, objet.posX / self.minimapRatio + objet.dimX / self.minimapRatio / 2, objet.posY / self.minimapRatio + objet.dimY / self.minimapRatio / 2, fill="blue")
        
        #On le redessine selon l'Ã©tat
        #self.afficherMenuEntite()
        #self.afficherFrameSelection()
        
        if self.frameMilieuLequel == "Selection" and self.nombreSelections != len(self.parent.canvas.uniteCourante):
            self.redessinerUniteSelectionne()
        
    def deplacerParLaMAP(self, event):
        self.deplacementX = event.x
        self.deplacementY = event.y
        
        self.parent.canvas.canvas.xview_scroll(-10000, UNITS)   # met les positions de la vue aux premiÃƒÂ¨re pour ensuite les mettre au position du clic *10
        self.parent.canvas.canvas.yview_scroll(-10000, UNITS)

        if event.x * self.minimapRatio - int(self.parent.canvas.width / 2) > self.parent.canvas.offsetXMax:    # si c'est trop a droite
            self.deplacementX = int(self.parent.canvas.offsetXMax / self.minimapRatio) + int((self.parent.canvas.width / 2) / self.minimapRatio)
        if event.x * self.minimapRatio - int(self.parent.canvas.width / 2) < 0:    # si c'est trop a gauche
            self.deplacementX = int((self.parent.canvas.width / 2) / self.minimapRatio)
            
        self.parent.canvas.canvas.xview_scroll(self.deplacementX * self.minimapRatio - int(self.parent.canvas.width / 2), UNITS)
        self.parent.canvas.offsetX = self.deplacementX * self.minimapRatio - int(self.parent.canvas.width / 2) #Change l'offset
        self.parent.minimap.posX = self.deplacementX - int((self.parent.canvas.width / 2) / self.minimapRatio) #Bouge le rectangle de la minimap
            
        if event.y * 10 - int(self.parent.canvas.height / 2) > self.parent.canvas.offsetYMax:    # si c'est trop en bas
            self.deplacementY = int(self.parent.canvas.offsetYMax / 10) + int((self.parent.canvas.height / 2) / self.minimapRatio)
        if event.y * 10 - int(self.parent.canvas.height / 2) < 0:    # si c'est trop en haut
            self.deplacementY = int((self.parent.canvas.height / 2) / self.minimapRatio)
            
        self.parent.canvas.canvas.yview_scroll(self.deplacementY * self.minimapRatio - int(self.parent.canvas.height / 2), UNITS)
        self.parent.canvas.offsetY = self.deplacementY * self.minimapRatio - int(self.parent.canvas.height / 2) #Change l'offset
        self.parent.minimap.posY = self.deplacementY - int((self.parent.canvas.height / 2) / self.minimapRatio)#Bouge le rectangle de la minimap
    
    def deplacerUnitesParLaMAP(self, event): 
        if(self.parent.canvas.uniteCourante):  #S'il y a des unites selectionnees
            for unite in self.parent.canvas.uniteCourante:
                if self.vueCourante.typeVue() == "Systeme":
                    self.parent.parent.deplacerUnite(unite[1], - 1, self.vueCourante.ID, event.x * self.minimapRatio, event.y * self.minimapRatio, 0)
                else:
                    self.parent.parent.deplacerUnite(unite[1], self.vueCourante.ID, self.vueCourante.systemeParent.ID, event.x * self.minimapRatio, event.y * self.minimapRatio, 0)  
   
   #affiche le menu ou on a le choix des actions    
    def afficherMenuEntite(self):
        # efface les choix de construction
        self.boutonsActionUnites.destroy()
        self.boutonsActionUnites = Frame(self.menu, width=200, height=140, background="blue", relief=RIDGE, borderwidth=3)
        
        self.boutonAttaque = Button(self.boutonsActionUnites, text="Attaque")
        self.boutonStop = Button(self.boutonsActionUnites, text="Stop")
        self.boutonSysteme = Button(self.boutonsActionUnites, text="Sortir de la planete", command=lambda:self.parent.parent.sortirUnitePlanete(self.parent.canvas.uniteCourante, self.parent.vueCourante.systemeParent.ID, self.parent.vueCourante.ID))

        #self.vueSelection.forget()
        self.boutonsActionUnites.pack(side=LEFT, fill=BOTH)
        self.boutonsActionUnites.propagate(0)

        if(len(self.parent.canvas.uniteCourante) > 0):
            self.boutonAttaque.pack(side=LEFT, expand=1)
            self.boutonStop.pack(side=LEFT, expand=1)
            if(self.parent.canvas.uniteCourante[0][0] == "Vaisseau"):
                self.boutonSysteme.pack(side=LEFT, expand=1)
            else:
                self.boutonSysteme.forget()
            
        elif(len(self.parent.canvas.uniteCourante) == 0):
            self.boutonAttaque.forget()
            self.boutonStop.forget()
            self.boutonSysteme.forget()

###### classe trouvé sur internet pour afficher une bulle d'information lorsqu'on met la sourris sur un élément du jeu... 
class ToolTip(object):

    def __init__(self, widget):
        self.widget = widget
        self.tipwindow = None
        self.id = None
        self.x = self.y = 0

    def showtip(self, text):
        "Display text in tooltip window"
        self.text = text
        if self.tipwindow or not self.text:
            return
        x, y, cx, cy = self.widget.bbox("insert")
        x = x + self.widget.winfo_rootx() + 27
        y = y + cy + self.widget.winfo_rooty() + 27
        self.tipwindow = tw = Toplevel(self.widget)
        tw.wm_overrideredirect(1)
        tw.wm_geometry("+%d+%d" % (x, y))
        try:
            # For Mac OS
            tw.tk.call("::tk::unsupported::MacWindowStyle",
                       "style", tw._w,
                       "help", "noActivates")
        except TclError:
            pass
        label = Label(tw, text=self.text, justify=LEFT,
                      background="#ffffe0", relief=SOLID, borderwidth=1,
                      font=("tahoma", "8", "normal"))
        label.pack(ipadx=1)

    def hidetip(self):
        tw = self.tipwindow
        self.tipwindow = None
        if tw:
            tw.destroy()

def createToolTip(widget, text):
    toolTip = ToolTip(widget)
    def enter(event):
        toolTip.showtip(text)
    def leave(event):
        toolTip.hidetip()
    widget.bind('<Enter>', enter)
    widget.bind('<Leave>', leave)
